// pages/main/user-profile/index.js
const apiService = require('../../../utils/api.js');
const auth = require('../../../utils/auth.js');
const app = getApp();

Page({

	/**
	 * 页面的初始数据
	 */
	data: {
		// 系统信息
		statusBarHeight: 0, // 状态栏高度，默认44px
		menuTop: 0, // 菜单按钮顶部距离
		menuHeight: 0, // 菜单按钮高度
		menuRight: 0, // 菜单按钮距离右边距离
		
		// 页面状态
		isLoading: false, // 加载状态
		
		// 用户信息
		userInfo: {
			nickName: '',
			avatar: '',
			balance: '0.00',
			couponCount: 0,
			isLogin: false
		},
		// 管理员状态
		isAdmin: false,
		// 商家端入口显示状态
		showMerchantEntry: false,
		// 宠物列表
		petList: [
			{
				id: 'pet_004',
				avatarUrl: '/assets/common/img_dog_avatar_default.png',
				nickname: '小白',
				category: 'dog',
				breed: '博美',
				birthDate: '2020-05-12',
				weight: 2.5,
				humanAge: 4,
				createdAt: 1589241600000,
				updatedAt: 1589241600000,
				gender: 1, // 公
				sterilized: false,
				photos: []
			},
			{
				id: 'pet_005',
				avatarUrl: '/assets/common/img_cat_avatar_default.png',
				nickname: '花花',
				category: 'cat',
				breed: '布偶猫',
				birthDate: '2021-01-08',
				weight: 3.8,
				humanAge: 3,
				createdAt: 1610035200000,
				updatedAt: 1610035200000,
				gender: 2, // 母
				sterilized: true,
				photos: []
			}
		],
		// 显示退出登录弹窗
		showLogoutModal: false
	},

	/**
	 * 生命周期函数--监听页面加载
	 */
	onLoad(options) {
		// 登录校验
		if (!auth.checkLoginStatus()) {
			// 未登录，直接跳转到登录页面
			auth.requireLogin();
			return;
		}
		
		// 防护性检查，避免 Foundation 相关错误
		try {
			this.initPage();
			this.loadUserData();
		} catch (error) {
			console.error('页面加载错误：', error);
		}
	},
	/**
	 * 初始化页面
	 * 获取系统信息、加载公告数据
	 */
	initPage() {
		// 获取系统信息，适配不同设备
		wx.getSystemInfo({
			success: (res) => {
				const menu = wx.getMenuButtonBoundingClientRect();
				
				console.log('menuTop', menu.top);
				console.log('menuHeight', menu.height);
				console.log('menuRight', res.windowWidth - menu.left);
				console.log('statusBarHeight', res.statusBarHeight || 44);
				
				this.setData({
					menuTop: menu.top,
					menuHeight: menu.height,
					menuRight: res.windowWidth - menu.left,
					statusBarHeight: res.statusBarHeight || 44
				});
			},
			fail: () => {
				console.warn('获取系统信息失败，使用默认状态栏高度');
			}
		});
	},
	/**
	 * 生命周期函数--监听页面显示
	 */
	async onShow() {
		console.log('[个人中心] 页面显示，开始重新加载数据');
		
		// 登录校验
		if (!auth.checkLoginStatus()) {
			// 未登录，直接跳转到登录页面
			auth.requireLogin();
			return;
		}
		
		// 立即更新TabBar状态，提升响应速度
		this.updateTabBarStatus(2);
		
		// 显示加载状态
		this.setData({ isLoading: true });
		
		// 强制刷新用户数据（清除缓存，确保获取最新数据）
		const dataManager = app.getDataManager();
		dataManager.invalidateUserCache();
		console.log('[个人中心] 已清除用户缓存，强制刷新数据');
		
		// 异步加载数据，不阻塞页面显示
		console.log('[个人中心] 调用 loadUserDataAsync 重新加载用户数据');
		this.loadUserDataAsync();
	},

	/**
	 * 异步加载用户数据（不阻塞页面显示）
	 */
	async loadUserDataAsync() {
		try {
			// 验证登录状态并刷新用户信息
			const isLoggedIn = await auth.validateLoginStatus();
			if (isLoggedIn) {
				// 使用DataManager并行加载用户信息和宠物列表，强制刷新宠物列表缓存
				const dataManager = app.getDataManager();
				console.log('[个人中心] 开始加载用户数据，强制刷新宠物列表');
				const [userInfoResult, petListResult] = await Promise.allSettled([
					this.getUserInfoWithCache(dataManager),
					dataManager.getPetList(true) // 强制刷新宠物列表缓存
				]);
				console.log('[个人中心] 数据加载完成，宠物列表结果:', petListResult);

				// 处理用户信息结果
				if (userInfoResult.status === 'fulfilled') {
					console.log('用户信息加载成功');
				} else {
					console.error('用户信息加载失败:', userInfoResult.reason);
				}

				// 处理宠物列表结果
				if (petListResult.status === 'fulfilled') {
					console.log('宠物列表加载成功');
					// 处理宠物列表数据
					const petData = petListResult.value;
					console.log('[个人中心] 获取到的宠物数据:', petData);
					console.log('[个人中心] 宠物数据长度:', petData ? petData.length : 0);
					if (petData && petData.length > 0) {
					// 转换数据格式以适配页面显示
					const petList = petData.map(pet => {
						const category = this.normalizeCategory(pet.category || pet.type);
						return {
							id: pet._id,
							displayAvatar: this.resolveAvatar(pet, category),
							nickname: pet.name,
							category: category,
							breed: pet.species || '未知品种',
							birthDate: pet.birthday ? this.formatDate(pet.birthday) : '',
							weight: pet.weight ? `${pet.weight}kg` : '0kg',
							humanAge: pet.birthday ? this.calculateAge(pet.birthday) : 0,
							createdAt: pet.createTime,
							updatedAt: pet.updateTime,
							gender: pet.gender === '公' ? 1 : 2,
							sterilized: pet.isSterilized,
							photos: []
						};
					});
						
						console.log('[个人中心] 准备更新页面宠物列表，数据长度:', petList.length);
						console.log('[个人中心] 宠物列表数据预览:', petList.slice(0, 2));
						this.setData({
							petList: petList
						});
						console.log('[个人中心] 页面宠物列表更新完成');
					} else {
						console.log('[个人中心] 宠物列表为空，清空页面数据');
						this.setData({ petList: [] });
						console.log('[个人中心] 空宠物列表设置完成');
					}
				} else {
					console.error('宠物列表加载失败:', petListResult.reason);
					console.log('[个人中心] 宠物列表加载失败，清空页面数据');
					this.setData({ petList: [] });
					console.log('[个人中心] 失败情况下宠物列表清空完成');
				}
			} else {
				// 登录状态无效，重置页面数据
				this.setData({
					'userInfo.isLogin': false,
					'userInfo.nickName': '请登录/注册',
					'userInfo.avatar': '',
					'userInfo.balance': '0.00',
					'userInfo.couponCount': 0
				});
			}
		} catch (error) {
			console.error('加载用户数据失败:', error);
		} finally {
			this.setData({ isLoading: false });
		}
	},

	/**
	 * 加载用户数据（使用缓存优化）
	 */
	loadUserData() {
		// 使用异步方法加载数据，优先使用缓存
		this.loadUserDataAsync();
	},

	/**
	 * 使用缓存获取用户信息
	 */
	async getUserInfoWithCache(dataManager) {
		try {
			if (!auth.checkLoginStatus()) {
				console.log('未登录状态');
				this.setData({
					'userInfo.isLogin': false,
					'userInfo.nickName': '请登录/注册',
					'userInfo.avatar': '',
					'userInfo.balance': '0.00',
					'userInfo.couponCount': 0
				});
				return;
			}

			// 使用DataManager获取用户信息，强制刷新以确保数据最新
			const userData = await dataManager.getUserProfile(true);
			
			// 获取优惠券数量（只统计未使用的优惠券）
			// 状态定义：1=未使用, 2=已使用, 3=已过期
			let couponCount = 0;
			try {
				// 使用 getUserCoupons 获取未使用的优惠券列表（状态=1表示未使用）
				const couponResult = await apiService.getUserCoupons(1, 1, 100); // 获取未使用的优惠券，最多100张
				if (couponResult && couponResult.success && Array.isArray(couponResult.data)) {
					// 进一步过滤：检查是否过期
					const now = Date.now();
					couponCount = couponResult.data.filter(coupon => {
						// 状态为1（未使用）且未过期
						const status = coupon.status || 0;
						const isUnused = status === 1;
						const expireTime = coupon.expireTime || coupon.expire_time;
						// 处理过期时间：可能是秒级时间戳或毫秒级时间戳
						let expireTimestamp = 0;
						if (expireTime) {
							if (typeof expireTime === 'number') {
								// 如果小于当前时间（秒），则认为是秒级时间戳，需要转换为毫秒
								expireTimestamp = expireTime < 10000000000 ? expireTime * 1000 : expireTime;
							} else {
								expireTimestamp = new Date(expireTime).getTime();
							}
						}
						const isExpired = expireTimestamp > 0 && expireTimestamp < now;
						return isUnused && !isExpired;
					}).length;
				}
			} catch (error) {
				console.error('获取优惠券数量失败:', error);
				// 失败时使用缓存数据
				try {
					const couponList = await dataManager.getCouponList({ status: 1 }, true);
					if (Array.isArray(couponList)) {
						const now = Date.now();
						couponCount = couponList.filter(coupon => {
							const status = coupon.status || 1;
							const expireTime = coupon.expireTime || coupon.expire_time;
							let expireTimestamp = 0;
							if (expireTime) {
								if (typeof expireTime === 'number') {
									expireTimestamp = expireTime < 10000000000 ? expireTime * 1000 : expireTime;
								} else {
									expireTimestamp = new Date(expireTime).getTime();
								}
							}
							const isExpired = expireTimestamp > 0 && expireTimestamp < now;
							return status === 1 && !isExpired;
						}).length;
					}
				} catch (fallbackError) {
					console.error('获取优惠券数量失败（降级方案）:', fallbackError);
				}
			}
			
			if (userData) {
				this.setData({
					'userInfo.isLogin': true,
					'userInfo.nickName': auth.formatNickName(userData),
					'userInfo.avatar': auth.formatAvatar(userData),
					'userInfo.balance': auth.formatBalance(userData.balance),
					'userInfo.couponCount': couponCount
				});

				// 检查管理员权限
				this.checkAdminPermission(userData);
				// 检查商家端入口权限
				this.checkMerchantEntryPermission(userData);
			} else {
				// 获取失败，显示未登录状态
				this.setData({
					'userInfo.isLogin': false,
					'userInfo.nickName': '请登录/注册',
					'userInfo.avatar': '',
					'userInfo.balance': '0.00',
					'userInfo.couponCount': 0
				});
			}
		} catch (error) {
			console.error('获取用户信息失败：', error);
			
			// 完全失败，显示未登录状态
			this.setData({
				'userInfo.isLogin': false,
				'userInfo.nickName': '请登录/注册',
				'userInfo.avatar': '',
				'userInfo.balance': '0.00',
				'userInfo.couponCount': 0
			});
		}
	},

	/**
	 * 获取用户信息（兼容旧方法）
	 */
	async getUserInfo() {
		const dataManager = app.getDataManager();
		return this.getUserInfoWithCache(dataManager);
	},

	/**
	 * 使用缓存获取宠物列表
	 */
	async getPetListWithCache(dataManager) {
		const token = wx.getStorageSync('token');
		if (!token) {
			this.setData({ petList: [] });
			return;
		}

		try {
			// 使用DataManager获取宠物列表，优先使用缓存
			const petData = await dataManager.getPetList();
			if (petData && petData.length > 0) {
				// 转换数据格式以适配页面显示
				const petList = petData.map(pet => ({
					id: pet._id,
					avatarUrl: pet.avatar || (pet.category === '狗狗' ? '/assets/common/img_dog_avatar_default.png' : '/assets/common/img_cat_avatar_default.png'),
					nickname: pet.name,
					category: pet.category === '狗狗' ? 'dog' : 'cat',
					breed: pet.species || '未知品种',
					birthDate: pet.birthday ? this.formatDate(pet.birthday) : '',
					weight: pet.weight ? `${pet.weight}kg` : '0kg',
					humanAge: pet.birthday ? this.calculateAge(pet.birthday) : 0,
					createdAt: pet.createTime,
					updatedAt: pet.updateTime,
					gender: pet.gender === '公' ? 1 : 2,
					sterilized: pet.isSterilized,
					photos: []
				}));
				
				this.setData({
					petList: petList
				});
			} else {
				this.setData({ petList: [] });
			}
		} catch (error) {
			console.error('获取宠物列表失败：', error);
			this.setData({ petList: [] });
		}
	},

	/**
	 * 获取宠物列表（兼容旧方法）
	 */
	async getPetList() {
		const dataManager = app.getDataManager();
		return await this.getPetListWithCache(dataManager);
	},

	/**
	 * 格式化日期
	 */
	formatDate(timestamp) {
		const date = new Date(timestamp * 1000);
		const year = date.getFullYear();
		const month = String(date.getMonth() + 1).padStart(2, '0');
		const day = String(date.getDate()).padStart(2, '0');
		return `${year}-${month}-${day}`;
	},

	/**
	 * 计算年龄
	 */
	calculateAge(timestamp) {
		const now = new Date();
		const birth = new Date(timestamp * 1000);
		const ageInMonths = (now.getFullYear() - birth.getFullYear()) * 12 + (now.getMonth() - birth.getMonth());
		
		if (ageInMonths < 12) {
			return `${ageInMonths}个月`;
		} else {
			const years = Math.floor(ageInMonths / 12);
			const months = ageInMonths % 12;
			return months > 0 ? `${years}岁${months}个月` : `${years}岁`;
		}
	},

	/**
	 * 将性别转换为表单格式
	 */
	convertGenderToForm(gender) {
		if (gender === 1) {
			return 'male';
		} else if (gender === 2) {
			return 'female';
		} else {
			return 'unknown';
		}
	},

	/**
	 * 用户信息区点击
	 */
	onUserInfoTap() {
		if (!auth.checkLoginStatus() || !this.data.userInfo.isLogin) {
			// 未登录，使用统一工具跳转到登录页面
			auth.requireLogin('/pages/main/user-profile/index');
		} else {
			// 已登录，显示个人资料编辑选项
			wx.showActionSheet({
				itemList: ['编辑个人资料', '退出登录'],
				success: (res) => {
					if (res.tapIndex === 0) {
						// 编辑个人资料
						wx.showToast({
							title: '个人资料编辑功能开发中',
							icon: 'none'
						});
					} else if (res.tapIndex === 1) {
						// 退出登录
						this.onLogoutTap();
					}
				}
			});
		}
	},

	/**
	 * 钱包点击
	 */
	onWalletTap() {
		// TODO: 测试用，后续删除
		if (!this.data.userInfo.isLogin && false) {
			this.showLoginTip();
			return;
		}
		wx.navigateTo({
			url: '/pages/pay/recharge/index',
			success: () => {
				console.log('跳转到充值页面成功');
			},
			fail: (error) => {
				console.error('跳转到充值页面失败：', error);
				wx.showToast({
					title: '页面跳转失败',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 优惠券点击
	 */
	onCouponTap() {
		// TODO: 测试用，后续删除
		if (!this.data.userInfo.isLogin && false) {
			this.showLoginTip();
			return;
		}
		wx.navigateTo({
			url: '/pages/pay/coupon-list/index',
			success: () => {
				console.log('跳转到优惠券列表页面成功');
			},
			fail: (error) => {
				console.error('跳转到优惠券列表页面失败：', error);
				wx.showToast({
					title: '页面跳转失败',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 添加宠物点击
	 */
	onAddPetTap() {
		// TODO: 测试用，后续删除
		if (!this.data.userInfo.isLogin && false) {
			this.showLoginTip();
			return;
		}
		// 埋点
		this.trackEvent('profile_add_pet_click', {
			user_id: wx.getStorageSync('userId')
		});
		
		// 跳转到宠物选择列表页面
		wx.navigateTo({
			url: '/pages/pet/select-list/index',
			success: () => {
				console.log('跳转到宠物选择列表页面成功');
			},
			fail: (error) => {
				console.error('跳转到宠物选择列表页面失败：', error);
				wx.showToast({
					title: '页面跳转失败',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 宠物卡片点击
	 */
	onPetTap(e) {
		const pet = e.currentTarget.dataset.pet;
		console.log('点击宠物卡片', pet);
		
		// 将宠物数据转换为页面参数格式
		const petParams = {
			id: pet.id,
			avatar: pet.avatarUrl,
			nickname: pet.nickname,
			category: pet.category,
			breed: pet.breed,
			gender: this.convertGenderToForm(pet.gender),
			birthDate: pet.birthDate,
			weight: String(pet.weight),
			mode: 'edit'
		};
		
		// 将参数编码并跳转到编辑页面
		const encodedParams = encodeURIComponent(JSON.stringify(petParams));
		wx.navigateTo({
			url: `/pages/pet/add-pet/index?data=${encodedParams}`,
			success: () => {
				console.log('跳转到宠物编辑页面成功');
			},
			fail: (error) => {
				console.error('跳转到宠物编辑页面失败：', error);
				wx.showToast({
					title: '页面跳转失败',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 订单tab点击
	 */
	onOrderTabTap(e) {
		const tab = e.currentTarget.dataset.tab;

		// 埋点
		this.trackEvent('profile_order_tab_click', {
			tab_key: tab
		});

		// 跳转到订单列表页，修正路径
		wx.navigateTo({
			url: `/pages/pay/order-list/index?status=${tab}`,
			success: () => {
				console.log('跳转到订单列表页面成功');
			},
			fail: (error) => {
				console.error('跳转到订单列表页面失败：', error);
				wx.showToast({
					title: '页面跳转失败',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 招商加盟点击
	 */
	onFranchiseTap() {
	},

	/**
	 * 问题反馈点击
	 */
	onFeedbackTap() {
		// 埋点统计
		this.trackEvent('profile_feedback_click', {
			user_id: wx.getStorageSync('userId'),
			timestamp: Date.now()
		});

		// 跳转到意见反馈页面
		wx.navigateTo({
			url: '/pages/user/feedback/index',
			success: () => {
				console.log('跳转到意见反馈页面成功');
			},
			fail: (error) => {
				console.error('跳转到意见反馈页面失败：', error);
				wx.showToast({
					title: '页面跳转失败',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 检查管理员权限
	 */
	async checkAdminPermission(userData) {
		try {
			// 获取当前用户的openId（这是真实的用户ID）
			const userId = wx.getStorageSync('userId'); // 这是openId
			
			if (!userId) {
				console.log('用户未登录，无法检查管理员权限');
				this.setData({
					isAdmin: false,
					adminInfo: null
				});
				return;
			}

			console.log('检查管理员权限，用户ID:', userId);

			// 调用API检查用户是否有管理员权限，传递正确的用户ID
			const result = await apiService.callFunction('admin', 'user/check_permission', {
				userId: userId
			});

			// 检查API返回的数据结构
			console.log('API返回结果:', result);
			
			// 安全地检查数据结构
			const hasPermission = result && 
				result.success && 
				result.data && 
				result.data.success && 
				result.data.data && 
				result.data.data.hasPermission === true;

			console.log('管理员权限检查结果:', hasPermission);
			
			if (hasPermission) {
				const adminInfo = result.data.data.adminInfo || null;
				this.setData({
					isAdmin: true,
					adminInfo: adminInfo
				});
				console.log('管理员权限检查成功:', adminInfo);
			} else {
				this.setData({
					isAdmin: false,
					adminInfo: null
				});
				console.log('用户无管理员权限:', result?.result?.data?.message || result?.message || '未知错误');
			}
		} catch (error) {
			console.error('检查管理员权限失败:', error);
			this.setData({
				isAdmin: false,
				adminInfo: null
			});
		}
	},

	/**
	 * 联系客服点击
	 */
	onServiceTap() {
		// 埋点统计
		this.trackEvent('profile_service_click', {
			user_id: wx.getStorageSync('userId'),
			timestamp: Date.now()
		});
		
		// 跳转到联系客服页面
		wx.navigateTo({
			url: '/pages/user/customer-service/index',
			success: () => {
				console.log('跳转到客服页面成功');
			},
			fail: (error) => {
				console.error('跳转到客服页面失败：', error);
				wx.showToast({
					title: '页面跳转失败',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 检查商家端入口权限
	 */
	async checkMerchantEntryPermission(userData) {
		try {
			// 安全起见，默认隐藏商家端入口
			this.setData({
				showMerchantEntry: false
			});

			// 获取当前用户的openId（这是真实的用户ID）
			const userId = wx.getStorageSync('userId'); // 这是openId
			
			if (!userId) {
				console.log('用户未登录，隐藏商家端入口');
				return;
			}

			// 测试模式：为所有用户开放商家端按钮入口（仅用于开发测试）
			const isTestMode = false; // 生产环境设为false，测试时设为true
			
			if (isTestMode) {
				this.setData({
					showMerchantEntry: true
				});
				console.log('测试模式：商家端入口已开放');
				return;
			}

			// 生产模式：只有关联了admin账号的用户才能看到商家端入口
			// 这里调用API检查用户是否有admin权限，传递正确的用户ID
			const result = await apiService.callFunction('admin', 'user/check_permission', {
				userId: userId
			});

			// 检查API返回的数据结构
			console.log('商家端权限检查API返回结果:', result);
			
			// 安全地检查数据结构
			const hasPermission = result && 
				result.success && 
				result.data && 
				result.data.success && 
				result.data.data && 
				result.data.data.hasPermission === true;

			console.log('商家端权限检查结果:', hasPermission);

			if (hasPermission) {
				this.setData({
					showMerchantEntry: true
				});
				console.log('用户具有admin权限，显示商家端入口');
			} else {
				this.setData({
					showMerchantEntry: false
				});
				console.log('用户无admin权限，隐藏商家端入口');
			}
		} catch (error) {
			console.error('检查商家端入口权限失败:', error);
			// 出错时默认隐藏
			this.setData({
				showMerchantEntry: false
			});
		}
	},

	/**
	 * 商家端点击
	 */
	onMerchantTap() {
		// 埋点统计
		this.trackEvent('profile_merchant_click', {
			user_id: wx.getStorageSync('userId'),
			timestamp: Date.now()
		});

		// 检查登录状态
		if (!this.data.userInfo.isLogin) {
			wx.showToast({
				title: '请先登录',
				icon: 'none'
			});
			return;
		}

		// 再次验证admin权限（双重保险）
		if (!this.data.isAdmin) {
			wx.showToast({
				title: '无权限访问商家端',
				icon: 'none'
			});
			return;
		}

		// 跳转到商家端登录页面（当前小程序内）
		wx.navigateTo({
			url: '/pages/merchant/login/index',
			success: () => {
				console.log('跳转到商家端登录页面成功');
				wx.showToast({
					title: '正在进入商家端',
					icon: 'loading',
					duration: 1000
				});
			},
			fail: (error) => {
				console.error('跳转到商家端登录页面失败:', error);
				wx.showToast({
					title: '页面跳转失败',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 管理后台点击
	 */
	onAdminTap() {
		// 埋点统计
		this.trackEvent('profile_admin_click', {
			user_id: wx.getStorageSync('userId'),
			timestamp: Date.now()
		});

		// 检查管理员权限
		if (!this.data.isAdmin) {
			wx.showToast({
				title: '无管理员权限',
				icon: 'none'
			});
			return;
		}

		// 跳转到管理后台登录页
		wx.navigateTo({
			url: '/pages/admin/login/index',
			success: () => {
				console.log('跳转到管理后台成功');
			},
			fail: (error) => {
				console.error('跳转到管理后台失败：', error);
				wx.showToast({
					title: '页面跳转失败',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 切换店家端点击
	 */
	onSwitchRoleTap() {
		// 埋点
		this.trackEvent('profile_switch_role_click', {
			role: 'merchant'
		});

		wx.showModal({
			title: '切换角色',
			content: '确定要切换到店家端吗？',
			success: (res) => {
				if (res.confirm) {
					// 切换到店家端
					wx.reLaunch({
						url: '/pages/admin/index/home/index'
					});
				}
			}
		});
	},

	/**
	 * 退出登录点击
	 */
	onLogoutTap() {
		if (!this.data.userInfo.isLogin) {
			return;
		}
		this.setData({
			showLogoutModal: true
		});
	},

	/**
	 * 弹窗遮罩点击
	 */
	onModalMaskTap() {
		this.setData({
			showLogoutModal: false
		});
	},

	/**
	 * 阻止事件冒泡
	 */
	stopPropagation() {
		// 空函数，阻止事件冒泡
	},

	/**
	 * 取消退出登录
	 */
	onCancelLogout() {
		this.setData({
			showLogoutModal: false
		});
	},

	/**
	 * 确认退出登录
	 */
	onConfirmLogout() {
		// 埋点
		this.trackEvent('profile_logout_click', {
			user_id: wx.getStorageSync('userId')
		});

		// 使用统一工具退出登录
		auth.logout(true, '/pages/user/login/index');
		
		// 隐藏弹窗
		this.setData({
			showLogoutModal: false
		});
	},

	/**
	 * 显示登录提示
	 */
	showLoginTip() {
		wx.showModal({
			title: '提示',
			content: '请先登录',
			showCancel: false,
			success: () => {
				wx.navigateTo({
					url: '/pages/user/login/index'
				});
			}
		});
	},

	/**
	 * 埋点上报
	 */
	trackEvent(eventName, params = {}) {
		// 这里可以接入统计SDK
		console.log('埋点上报：', eventName, params);
		
		// 示例：接入微信统计或第三方统计SDK
		// wx.reportAnalytics(eventName, params);
	},

	/**
	 * 页面相关事件处理函数--监听用户下拉动作
	 */
	onPullDownRefresh() {
		this.loadUserData();
		// 停止下拉刷新
		setTimeout(() => {
			wx.stopPullDownRefresh();
		}, 1000);
	},

	/**
	 * 更新TabBar状态的统一方法
	 * @param {number} selectedIndex TabBar选中索引
	 */
	updateTabBarStatus(selectedIndex) {
		console.log(`[用户资料页面] 更新TabBar状态: ${selectedIndex} (${this.data.list?.[selectedIndex]?.text || '未知'})`);
		
		// 验证索引有效性
		if (selectedIndex < 0 || selectedIndex > 2) {
			console.error(`[用户资料页面] TabBar索引无效: ${selectedIndex}，有效范围: 0-2`);
			return;
		}
		
		if (typeof this.getTabBar === 'function') {
			// 多重保障的TabBar状态更新
			try {
				const tabBar = this.getTabBar();
				if (tabBar) {
					// 传统模式
					console.log('[用户资料页面] 传统模式更新TabBar');
					if (tabBar.setSelected) {
						tabBar.setSelected(selectedIndex);
						console.log(`[用户资料页面] 通过setSelected更新TabBar: ${selectedIndex}`);
					} else {
						tabBar.setData({ selected: selectedIndex });
						console.log(`[用户资料页面] 通过setData更新TabBar: ${selectedIndex}`);
					}
				} else {
					// skyline模式 - 异步回调
					console.log('[用户资料页面] Skyline模式异步更新TabBar');
					this.getTabBar((tabBar) => {
						if (tabBar) {
							if (tabBar.setSelected) {
								tabBar.setSelected(selectedIndex);
								console.log(`[用户资料页面] Skyline异步通过setSelected更新TabBar: ${selectedIndex}`);
							} else {
								tabBar.setData({ selected: selectedIndex });
								console.log(`[用户资料页面] Skyline异步通过setData更新TabBar: ${selectedIndex}`);
							}
						} else {
							console.warn('[用户资料页面] Skyline异步获取TabBar失败');
						}
					});
				}
			} catch (error) {
				console.error('[用户资料页面] TabBar状态更新失败:', error);
				// 降级处理：尝试异步调用
				try {
					this.getTabBar((tabBar) => {
						if (tabBar) {
							if (tabBar.setSelected) {
								tabBar.setSelected(selectedIndex);
								console.log(`[用户资料页面] 降级处理通过setSelected更新TabBar: ${selectedIndex}`);
							} else {
								tabBar.setData({ selected: selectedIndex });
								console.log(`[用户资料页面] 降级处理通过setData更新TabBar: ${selectedIndex}`);
							}
						} else {
							console.warn('[用户资料页面] 降级处理获取TabBar失败');
						}
					});
				} catch (asyncError) {
					console.error('[用户资料页面] TabBar异步更新也失败:', asyncError);
				}
			}
		} else {
			console.warn('[用户资料页面] getTabBar方法不可用');
		}
	},

	/**
	 * 全局刷新用户数据方法
	 * 供其他页面调用，确保登录后数据正确显示
	 */
		refreshUserData() {
			console.log('个人资料页面：刷新用户数据');
			this.loadUserData();
		},

		normalizeCategory(val) {
			const s = String(val || '').toLowerCase();
			if (/狗/.test(val || '') || s === 'dog') return 'dog';
			return 'cat';
		},

		resolveAvatar(pet, category) {
			const raw = pet && (pet.avatar || pet.avatarUrl) || '';
			const def = category === 'dog' ? '/assets/common/img_dog_avatar_default.png' : '/assets/common/img_cat_avatar_default.png';
			if (!raw) return def;
			if (/img_pet_avatar_default\.png|icon_pet_default\.png/.test(raw)) return def;
			if (/img_(dog|cat)_avatar_default\.png/.test(raw)) return def;
			const ok = raw.startsWith('https://') || raw.startsWith('cloud://') || raw.startsWith('/assets/');
			return ok ? raw : def;
		}
})
